Knowledge representation using geometric flexible adaptable templates a new machine learning methodology

ABSTRACT

This invention relates to the machine recognition and learning of predetermined categories and more generally, to the representation of patterns, information and knowledge in computational applications. A method of learning categories is an important component of advanced software technology. This invention has applications in the following areas: bioinformatics, document classification, document similarity, financial data mining, goal-based planners, handwriting and character recognition, information retrieval, natural language processing, natural language understanding, pattern recognition, search engines, strategy based domains such as business, military and games, and vision recognition.

I. FEDERALLY SPONSORED RESEARCH

[0001] NOT APPLICABLE.

II. COMPUTER PROGRAM

[0002] Attached with this patent application is a CD-ROM. There is JAVA source code stored on the enclosed CD-ROM in the directory Krugfat. The JAVA source code shows a sample implementation of Krugfat.

III. BACKGROUND—FIELD OF INVENTION

[0003] Many researchers have attempted to develop flexible knowledge representation and machine learning methodologies to solve problems in the field of machine intelligence (AI), and explain theories of the mind in cognitive psychology. The machine learning methodology presented here is a subset of a theory and methodology developed to overcome many of the knowledge representation and machine learning difficulties encountered over the past 50 years.

[0004] In particular, this invention relates to the machine recognition and learning of predetermined categories. A method of learning categories is an important component of advanced software technology, cognitive psychology, and philosophy, [WITTGENSTEIN].

IV. ADVANTAGES OF INVENTION OVER PRIOR ART

[0005] 1.) A substantial part of the uniqueness and novelty of KRUGFAT is that its machine learning system exploits the advantages of bottom-up components and top-down components, while avoiding their respective disadvantages. As many researchers in the field of AI and cognitive science have recognized over the last 20 to 30 years, certain types of cognitive tasks are better performed by bottom-up machine learning and knowledge representation methodologies, and others are better performed by top-down methods, [MINSKY].

[0006] A typical bottom-up learning algorithm and representation is a feedforward neural network using a back propagation training algorithm. [HERTZ, KROGH, PALMER] Other types of cognitive tasks are better performed by strictly top-down methodologies as IBM's Deep Blue software program that plays chess [DEEP BLUE], and Hammond's CHEF program which creates new cooking recipes by adapting old recipes, [RIESEBECK, SCHANK].

[0007] a.) An advance of KRUGFAT is that typical bottom-up methodologies, do not store any prototypical examples, or do not construct an adaptable template that represents a prototypical combination of the examples. KRUGFAT enables the synthesis of prototypical examples. The utilization of prototypical examples greatly increases machine learning accuracy and speed.

[0008] b.) An improvement of KRUGFAT is over top-down methodologies. A weakness of strictly top-down methodologies is that the building blocks or knowledge representation of that particular domain—in CHEF it would be all the primitives about FOOD, COOKING, and RECIPES—are fixed and pre-defined by the software developer (a human being). This makes the knowledge representation of the software brittle. As a consequence, the program has no basis for dealing with a new example that is applied to different circumstances, [FEYNMAN]. On the other hand, KRUGFAT builds its templates and template maps so that it robustly handles new examples.

[0009] c.) KRUGFAT has flexibility in creating many applications of machine learning and knowledge representation across many different applications: bioinformatics, document classification, document similarity, financial data mining, goal-based planners, handwriting and character recognition, information retrieval, natural language processing and response, natural language understanding, pattern recognition, search engines, strategy based domains such as business, military and games, and vision recognition. However, the previous list does riot cover all possible applications of KRUGFAT.

[0010] 2.) A substantial improvement of the learning process in KRUGFAT over alternative training methods is that it does not get stuck in local minima, [FISKE1]. The learning phase of KRUGFAT avoids local minima problems because it does not use a locally “greedy” optimization algorithm such as gradient descent, [HERTZ, KROGH, PALMER]. Many bottom-up systems suffer from the local minima problem. Because of the local minima problem, often times it can takes weeks or months to satisfactorily train a program implementing a practical application. In some cases, gradient descent may NEVER train satisfactorily in a practical amount of time.

[0011] 3.) The KRUGFAT learning phase is much faster than previous methods. For example, to construct all the templates necessary to distinguish between any two handwritten letters takes about 30 minutes on a Pentium III, 900 Mhz laptop. Typical neural network training times for handwriting recognition often take a few days or more than a week, depending on the computing resources used during the training.

[0012] 4.) The KRUGFAT recognition phase is much faster than previous methods. It exploits the “exponential principle” to increase its speed. As an example of this speed, consider a program that recognizes Chinese characters. According to a web source, 171,882,493 Chinese characters appeared on Usenet newsgroups from 1993-1994, [CHINESE CHARACTERS]. Some estimates state that there are 180 million distinct categories of Chinese characters. If the software constructs a set of templates that on average eliminate ⅓ of the remaining Chinese character categories, then this means that one trial of the recognition phase on average uses only 46 randomly chosen templates to reduce 180 million potential Chinese categories down to a single character. (46 templates is computed by finding the smallest exponent n satisfying the inequality (180,000,000)*(⅔)^(n)<2.)

V. DETAILED DESCRIPTION OF THE INVENTION

[0013] Section A explains the vocabulary and concepts necessary to KRUGFAT's present the recognition phase and learning phase in sections B and C. Section D discusses Unbounded Building Block Evolution, which can be used to enhance the learning phase. Section E applies KRUGFAT to handwriting recognition. Section F applies KRUGFAT to document classification and information retrieval. Section G applies KRUGFAT to gene expression. Section H explains template maps of templates.

[0014] A. Vocabulary and Definitions

[0015] The first element of KRUGFAT is a space C, called a category space. Often a space is a mathematical set, but it could have more structure than a set. For this reason, the word ‘space’ is used instead of ‘set’. For a well-written introduction to set theory, the first twenty pages of [HALMOS] is excellent.

[0016] If the category space is about concepts that are living creatures, then typical members of C are the categories: “dog”, “cat”, “animal”, “mammal”, “tiger”, “lizard”, “starfish”, “tree”, “birch tree”, “cherry tree”, “barley”. A different type of a category space is the letters of our alphabet: {a, b, c, d, c, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z}. Another more abstract type of category space could be the functional purpose of genes. One category is any gene that influences eye color; another category is any gene that codes for enzymes used in the liver; another category is any gene that codes for membrane proteins used in neurons; and there are thousands more functional categories that genes code for. In short, the structure of the category space depends upon what set of possibilities that you want the software to retrieve, recognize, categorize or classify.

[0017] Another important concept is the possibility space E. The possibility space is the set of every possible example that anyone could ever conceive of. If you were to write a software program that recognizes handwritten letters for the English language, then the possibility space would include every handwritten ‘a’ ever written and any ‘a’ that could be written in the future; and every handwritten ‘b’ ever written and any ‘b’ that could be written in the future; . . . ; and every handwritten ‘z’ ever written and any ‘z’ that could be written in the future.

[0018] There are also a set of learning examples: {e₁, e₂, . . . e_(m)} which is a subset of the possibility space E. The learning examples are the particular list of examples used to train the software program. There is a God function, also called the God map, G:E→P(C) where P(C) is the power set of C. (Recall that the power set is the set of all subsets. If the set is S={“dog”, “cat”}, then the power set of S, P(S)={, {“dog”}, {“cat”}, {“dog”, “cat”}}.

[0019] What this means is that each example e in E is classified as lying in 0, 1 or many categories. It is called a God map because God knows exactly what categories any example from the possibility space is in, but software programs and human beings sometimes do not know. An illustration of this is the example e=“Morris the Cat” lies in the categories “cat”, “animal”, “mammal”. In other words, G(e)={“cat”, “animal”, “mammal”}. The purpose of the machine learning methodology is to construct a function g:E→P(C) so that g(e)=G(e) for every example e in the possibility space E. Obviously, G is the ideal or perfect function that a person or computer program wishes to learn: this is why G is called the God map.

[0020] The next important concept is that of a template. A template is anything that can be used to distinguish between two different categories of patterns, information or knowledge. For example, if the two different categories are the letters ‘a’ and ‘l’, then “the shape has a loop in it” is a template because it distinguishes ‘a’ from ‘l’.

[0021] The expression {T₁, T₂, . . . , T_(n)} denotes a collection of templates, called the template set. Associated to each template, there can be a corresponding template value function T_(i):E→V, where V is a template value space. There are no restrictions made on the structure of V. V may be equal to a subset of the real line, a subset of the integers, a discrete set, a manifold, or even a function space.

[0022] The symbol P(V) denotes the power set of V. Each template T_(i) can have a corresponding prototype function T_(i):C→P(V). This prototype function is constructed during the learning phase. If c is a category in C, T_(i)(c) equals the set of prototypical template values that one expects for all examples e that lie in category c. Intuitively, the prototype function is a measure of the template's generalization properties.

[0023] For each (template, category) pair (T_(i), c), there is a matching function M_((T) _(i) _(,c)), which tells us if the template value is similar enough to its set of prototypical values. Thus, M_((T) _(i) _(,c)):V→S, where S is the similarity space.

[0024] An example of a specific matching function is described here. In this particular example, choose V={0, 1}. Further, choose the similarity space S equal to {0, 1}. Consider a template value ν₁. If ν₁ is similar to its prototypical set T_(i)(c), then M_((T) _(i) _(,c))(ν₁)=1. If ν₁ is not similar enough to its prototypical set T_(i)(c), then M_((T) _(i) _(,c))(ν₁)=0.

[0025] Assume there are two categories {c₁, c₂} and two templates {T₁, T₂}. Assume the prototypical functions for T₁ and T₂ are defined as: T₁(c₁)={1} and T₁(c₂)={0, 1}. T₂(c₁)={0, 1} and T₂(c₂)={0}.

[0026] Then there are 4 distinct matching functions: M_((T) ₁ _(,c) ₁ ₎, M_((T) ₂ _(,c) ₁ ₎, M_((T) ₁ _(,c) ₂ ₎, M_((T) ₂ _(,c) ₂ ₎.

[0027] The functions are defined as follows:

[0028] 1.) M_((T) ₁ _(,c) ₁ ₎(0)=0 AND M_((T) ₁ _(,c) ₁ ₎(1)=1

[0029] 2.) M_((T) ₂ _(,c) ₁ ₎(0)=1 AND M_((T) ₂ _(,c) ₁ ₎(1)=1

[0030] 3.) M_((T) ₁ _(,c) ₂ ₎(0)=1 AND M_((T) ₁ _(,c) ₂ ₎(1)=1

[0031] 4.) M_((T) ₂ _(,c) ₂ ₎(0)=1 AND M_((T) ₂ _(,c) ₂ ₎(1)=0

[0032] The previous matching function is defined in a simple way to make the concept easier to understand. The similarity space S is the range of the matching function, and is sometimes equal to the unit interval [0, 1], to a subset of

^(n), a discrete set, or even a function space.

[0033] Each template T_(i) also has a corresponding probability p_(i) of being chosen in the recognition phase. Let m be the number of trials, and ρ be the number of templates randomly chosen in each trial. θ is the acceptable category threshold, and is represented by a real number between 0 and 1.

[0034] For each category c in C, there is a corresponding category score s_(c). The score s_(c) measures to what extent the program believes the example—it is trying to recognize—is in category c. Now that the fundamental concepts are defined, two primary processes of the machine learning system are explained: RECOGNITION and LEARNING.

[0035] B. Recognition

[0036] The expression e_(cat) denotes an example from the possibility space that the software is supposed to classify, categorize, or recognize. Below is an implementation of the recognition phase.

[0037] Allocate memory and read learned templates from long-term memory

[0038] Initialize every category score s_(c) to zero.

[0039] OUTER LOOP: m trials. { Initialize set S equal to C. INNER LOOP: Choose ρ templates randomly. { Choose template, T_(k, with probability distribution p) _(i). For each category c in S { IF M_((T) _(k) _(,c)) (T_(k)(e_(cat)) ) equals zero THEN remove category c from S. (set S = S − {c}) } } For each category c remaining in S { Increment the category score s_(c).  } }

[0040] Initialize A to the empty set.

[0041] For each category c in C, IF (s_(c)/m)>θ, THEN add category c to A.

[0042] The answer is A. The example e_(cat) is in the categories that are in A.

[0043] Comments on Recognition:

[0044] 1.) If for some reason only the best category is returned as an answer, rather than multiple categories, then do this by replacing the step:

[0045] For each category c in C, IF (s_(c)/m)>θ, THEN add category c to A.

[0046] Instead, search for the maximum category score if there are a finite number of categories. The answer is a single category that has a maximum category score. If there are an infinite number of categories in C, then take the supremum over all s_(c) and use a category space that is complete assuring that the category corresponding to the supremum lies in C.

[0047] 2.) If the template space V and the similarity space S have more structure, then the step:

[0048] IF M_((T) _(k) _(,c))(T_(k)(e_(cat))) equals zero is replaced by the more general step:

[0049] IF T_(k)(e_(cat)) is NOT close to its prototypical value set T_(k)(c).

[0050] C. Learning

[0051] The initial part of the learning phase involves the construction of the templates from simple building blocks, using the examples and the categories to guide the construction. One method is for a person, user-created, to construct the templates based oil his or her expertise on the application. Another method is to use evolution implemented in hardware and/or software; described in section D, Unbounded Building Block Evolution, applied to template design, can build template value functions T_(a):E→V from a collection of building block functions {ƒ₁, ƒ₂, ƒ₃, . . . , ƒ_(r)}.

[0052] The remaining parts of the learning phase primarily involve constructing the matching functions M_((T) _(i) _(,c)), constructing the prototype functions T_(i):C→V, setting the threshold θ, and computing the probabilities p_(i).

[0053] With this in mind, start with a collection of learning examples along with the categories that each example lies in. The type of template values—the members of V—boolean, real, or functions enable many different methods for constructing the prototype functions, and matching functions. For clarity, template values used below are boolean, but in the more general case the template values can be real numbers, points on a manifold, or even functions.

[0054] As stated above, assume that V={0, 1}, where 0 represents false and 1 represents true. In this case, each matching function M is easily determined: M_((T) _(i) _(,c))(ν)=1 if ν lies in the prototypical set T_(i)(c); and M_((T) _(i) _(,c))(ν)=0 if ν does NOT lie in the prototypical set T_(i)(c).

[0055] In the case where V is a continuum, for example, V can be the interval [0, 1], the circle S¹, or any other manifold, or any measurable space. Because there are an infinite number of spaces that V can represent, there are many ways of constructing the matching functions M_((T) _(i) _(,c)).

[0056] With the previous in mind, below is an implementation of the learning phase—in particular, the construction of the prototype functions.

[0057] Allocate memory for the templates and read the templates from long-term memory, into the template set, {T₁, T₂, . . . , T_(n)}. The templates read from long-term memory were user-created, created by Unbounded Building Block Evolution, or an alternative method.

[0058] OUTER LOOP: Iterate thru each template T_(k) { Initialize S = T_(k)(c₁). Initialize A = S. INNER LOOP: Iterate thin each category c_(i) { Let E_(c) _(i) = the set of learning examples lying in category c_(i). Construct the prototype function T_(k) as follows: Set T_(k)(c_(i)) EQUAL to the union of all template values v satisfying v = T_(k)(e) for some example e lying in E_(c) _(i) . Set A equal to A ∪ T_(k)(c_(i)). }

[0059] If A EQUALS S remove template T_(k) from the template set. }

[0060] Store templates, remaining in the template set, in long-term memory.

[0061] Comments on Learning:

[0062] 1.) The learning assumes that there are a finite number of categories, q.

[0063] 2.) Setting the category threshold θ is best determined empirically. In the information retrieval application a threshold in the range of 0.5 to 0.7 yields the highest accuracy. In the handwriting recognition application a threshold range of 0.7 to 0.9 is the most accurate.

[0064] 3.) For a fixed template, T_(k), there has to be at least one pair of categories (c_(i), c_(j)) such that T_(k)(c_(i))≠T_(k)(c_(j)). Otherwise, template T_(k) can not separate any categories and thus, the program should remove template T_(k).

[0065] 4.) In tests, an average accuracy of greater than 85% and average recognition speed of one second was obtained, using a uniform probability distribution, p_(i)=p_(j) for all i, j. However, some difficult categorization areas can benefit from a non-uniform probability distribution. In particular, we know that in some cases templates that do a better job of separating categories should have a higher probability of being chosen. For example, in Bioinformatics applications, one can construct a non-uniform probability distribution to create a voting procedure. In all applications tested, the results are at least 77% better when the behavior of the templates is, dependent on the categories remaining in the recognition phase.

[0066] D. Unbounded Building Block Evolution

[0067] This section presents a unique evolution called Unbounded Building Block Evolution, UBBE. UBBE can be used on its own for applications outside of KRUGFAT or used in the learning phase described in section C.

[0068] The first implementation of UBBE described here designs the template value functions T_(a):E→V, using the categories, examples and the building block functions. However, UBBE is flexible and general enough to build other elements besides templates from a collection of simple building blocks. The more general method of UBBE is explained toward the end of this section.

[0069] The use of an evolutionary process was first introduced by [BLEDSOE], [BOX], [BREMERMANN] and [FRIEDMAN] and further developed by [HOLLAND_(—)1] and [HOLLAND_(—)2]. At end of this section, the advantages of UBBE over prior art are discussed.

[0070] UBBE draws from a collection of building blocks and composes them together to build a useful element. In many cases, the building blocks are a collection of functions ƒ_(λ):X→X, where λεΛ, X is a set and Λ is an index set. In some cases, X is the set of real numbers, but it also may be a discrete set or a set with a different structure than a set of numbers. In handwriting recognition, covered in section E, the binary functions addition, subtraction, multiplication, and division comprise the building blocks. Further, in handwriting recognition X is the rational numbers. The index set, Λ={1, 2, 3, 4}, has four elements. In other words, there are four building blocks: ƒ₁=+, ƒ₂=−, ƒ₃=*, and ƒ₄=/. In some cases, the index set may be infinite. For example, the functions ƒ_(λ):

→

, such that ƒ(x)=x+λ is an infinite number of building blocks because λ can take on an infinite number of values.

[0071] Before UBBE applied to template design is explained, the method of using bit-sequences to encode functions composed from building block functions will be discussed. A bit-sequence is a sequence of ones and zeroes, [b₁, b₂, b₃, . . . , b_(n)], where n is called the length. As an example, [1, 0, 1, 1, 0] is a bit-sequence, and the length is 5. (Observe that any set of symbols or numbers can be represented by distinct sequences of bits, so all methods of using bit-sequences here also apply to other sequences.)

[0072] The expression {ƒ₁, ƒ₂, ƒ₃, . . . , ƒ_(r)} denotes the building block functions, where r=2^(K) for some K. Then K bits uniquely represent one building block function. The arity of a function is the number of arguments that it requires. For example, the arity of the real-valued quadratic function ƒ(x)=x² is 1. The arity of the projection function, P_(i):X^(n)→X, is n, where P_(i)(x₁, x₂, . . . , x_(n))=x_(i).

[0073] A bit-sequence can represent the composition of building block functions. Define the building block function v as v(x,y,z)=x if (x≧y AND x≧z), else v(x,y,z)=y if (y≧x AND y≧z), else v(x,y,z)=z. To keep this example easy to understand, use four building block functions, {+, −, *, v}. Each sequence of two bits uniquely corresponds to one of these building block functions:

00

+01

−10

*11

v

[0074] The bit-sequence [00, 01] with length 4, encodes the function +(−(x₁, x₂), x₃)=(x₁−x₂)+x₃. Observe that this function has arity 3. The bit-sequence [10, 01, 00, 11] with length 8, encodes the function *(−(v(x₁, x_(2, x) ₃), x₄), +(x₅, x₆))=(v(x₁, x₂, x₃)−x₄)*(x₅+x₆). This function has arity 6. The bit-sequence [11, 00, 01, 10, 00, 01, 01, 10, 00, 10] encodes the function

[0075] v(+(+(x₁, x₂), −(x₃, x₄)), −(−(x₅, x₆), *(x₇, x₈)), *(+(x₉, x₁₀), *(x₁₁, x₁₂))=v(x₁ 30 x₂ 30 x₃−x₄, x₅−x₆−(x₇*x₈), (x₉+x₁₀)*x₁₁*x₁₂). This function has arity 12.

[0076] For the general case, consider the building block functions, {ƒ₁, ƒ₂, ƒ₃, . . . , ƒ_(r)}, where r=2^(K). Any bit-sequence, [b₁b₂ . . . b_(K), b_(K+1)b_(K+2) . . . b_(2K), . . . , b_(aK+1)b_(aK+2) . . . b_((a+1)K)], with length (a+1)K is a composition of the building block functions, {ƒ₁, ƒ₂, ƒ₃, . . . , ƒ_(r)}. The composition of these r building block functions is encoded in a similar manner to the example with building block functions, {+, −, *, v}.

[0077] This paragraph defines other objects used in the template design. The distinct categories are {C₁, C₂, . . . , C_(N)}. The population size of each generation is m. For each i, where 1≦i≦N, E_(C) _(i) is the set of all learning examples that lie in category C_(i). The symbol θ is an acceptable level of performance for a template. The symbol Q is the number of distinct templates whose fitness must be greater than θ. The symbol p_(crossover) is the probability that two templates chosen for the next generation will be crossed over. The symbol p_(mutation) is the probability that a template will be mutated.

[0078] The overall steps of UBBE applied to template design are summarized in this paragraph. For each category pair (C_(i), C_(j)), i<j, the building blocks, {ƒ₁, ƒ₂, ƒ₃, . . . , ƒ_(r)}, are used to build a population of m templates. This is accomplished by choosing m multiples of K, {l₁, l₂, . . . , l_(m)}. For each l_(i), a bit sequence of length l_(i) is constructed. These m bit sequences represent the m templates, {T₁ ^((i,j)), T₂ ^((i,j)), T₃ ^((i,j)), . . . , T_(m) ^((i,j))}. The superscript (i, j) represents that these templates are evolved to distinguish examples chosen from E_(C) _(i) and E_(C) _(j) . The fitness of each template is determined by how well the template can distinguish examples chosen from E_(C) _(i) and E_(C) _(j) . The idea is to repeatedly evolve the population of bit-sequences, using crossover and mutation, until there are at least Q, (Q>0), templates which have a fitness greater than θ. When this happens, choose the Q best templates, at distinguishing categories C_(i) and C_(j), from the population. Store these Q best templates in a distinct set,

, of high quality templates that are later used in the learning described in section C.

[0079] UBBE that designs high quality temiplates

is presented below.

Unbounded Building Block Evolution Applied to Template Design

[0080] Set

equal to the empty set. For each i in {1,2,3,...,N} For each j in {i+1,i+2,...,N} { Build an initial population, A_((i,j)) = {T₁ ^((i,j)),T₂ ^((i,j)),T₃ ^((i,j)),...,T_(m) ^((i,j))}, of templates, represented as m bit-sequences. Set q equal to zero. while( q < Q) { Set G equal to the empty set. while( size of G < m) { Randomly choose two templates, T_(a) ^((i,j)), T_(b) ^((i,j)), from A, where the probability of choosing a template for the next generation is proportional to its fitness . Randomly choose a number r between 0 and 1. If r < p_(crossover), then crossover templates T_(a) ^((i,j)) and T_(b) ^((i,j)). Randomly choose numbers s₁, s₂ between 0 and 1. If s₁ < p_(mutation), then mutate template T_(a) ^((i,j)). If s₂ <p_(mutation), then mutate template T_(b) ^((i,j)). Set G equal to G ∪ {T_(a) ^((i,j)), T_(b) ^((i,j))}. } Set A_((i,j)) equal to G. For each template T_(a) ^((i,j)) in A_((i,j)), evaluate its ability to distinguish examples from categories C_(i) and C_(j). Store this ability as the fitness of T_(a) ^((i,j)). Set q equal to the number of templates with fitness greater than θ. } Choose the Q best templates, based on fitness, from A_((i,j)) and add them to

. }

Comments on UBBE

[0081] 1.) The fitness φ_(a) of a template, T_(a) ^((i,j)), is measured by computing a weighted average of the following criteria:

[0082] The ability of a template to distinguish examples lying in E_(C) _(i) from examples lying in E_(C) _(j)

[0083] The amount of memory consumed by the template.

[0084] The average amount of computational time it takes to compute the template value function on the examples from E_(C) _(i) and E_(C) _(j) .

[0085] A quantitative measure for the first criteria depends on the topology of the template value space, V. If V is {0, 1}, the ability of template T_(a) ^((i,j)) to distinguish examples in E_(C) _(i) from examples in E_(C) _(j) equals $\frac{1}{\left| E_{C_{i}}||E_{C_{j}} \right|}{\sum\limits_{e_{j} \in E_{C_{j}}}^{\quad}{\sum\limits_{e_{i} \in E_{C_{i}}}^{\quad}{{{{T_{a}^{({i,j})}\left( e_{i} \right)} - {T_{a}^{({i,j})}\left( e_{j} \right)}}}.}}}$

[0086] Recall that |E_(C) _(i) | is the number of examples in the set |E_(C) _(i) |, and |E_(C) _(j) | is the number of examples in the set |E_(C) _(j) |. Further, T_(a) ^((i,j))(e_(i)) equals the result of the template value function of T_(a) ^((i,j)) applied to the example e_(i). T_(a) ^((i,j))(e_(j)) equals the result of the template value function of T_(a) ^((i,j)) applied to the example e_(j). These values are 1 or 0 when V={0, 1}. The expression |T_(a) ^((i,j))(e_(i))−T_(a) ^((i,j))(e_(j))| is the absolute value of the difference between T_(a) ^((i,j))(e_(i)) and T_(a) ^((i,j))(e_(j)). For each example e_(j) from the set E_(C) _(j) , a sum, ${\sum\limits_{e_{i} \in E_{C_{i}}}^{\quad}{{{T_{a}^{({i,j})}\left( e_{i} \right)} - {T_{a}^{({i,j})}\left( e_{j} \right)}}}},$

[0087] is computed as e_(i) runs over all examples from the set E_(C) _(i) , and then each of these sums is summed together to yield, the total sum $\sum\limits_{e_{j} \in E_{C_{j}}}^{\quad}{\sum\limits_{e_{i} \in E_{C_{i}}}^{\quad}{{{{T_{a}^{({i,j})}\left( e_{i} \right)} - {T_{a}^{({i,j})}\left( e_{j} \right)}}}.}}$

[0088] This total has |E_(C) _(i) ∥E_(C) _(j) | terms that are summed.

[0089] In the other cases, when V is not {0, 1}, then V has a metric, D, or a metric can be defined on V. A metric D is a method for measuring the distance between two points in the template value space V. When V is not {0, 1}, the ability of template T_(a) ^((i,j)) to distinguish examples in E_(C) _(i) from examples in E_(C) _(j) equals $\frac{1}{\left| E_{C_{i}}||E_{C_{j}} \right|}{\sum\limits_{e_{j} \in E_{C_{j}}}^{\quad}{\sum\limits_{e_{i} \in E_{C_{i}}}^{\quad}{{D\left( {{T_{a}^{({i,j})}\left( e_{i} \right)},{T_{a}^{({i,j})}\left( e_{j} \right)}} \right)}.}}}$

[0090] The amount of memory consumed by the template usually measures the number of bytes the template uses during runtime. The amount of computational time is measured at runtime.

[0091] 2.) The diagram titled, Unbounded Crossover, demonstrates a crossover between two bit-sequences, A=[a₁, a₂, a₃, . . . , a_(L)] and bit-sequence B=[b₁, b₂, b₃, . . . b_(M)]. Keep in mind that L and M are each multiples of K, where r=2^(K) and the primitive functions are {ƒ₁, ƒ₂, ƒ₃, . . . , ƒ_(r)}. Also, in general L≠M. Two natural numbers u and w are randomly chosen such that 1≦u≦L, 1≦w≦M and u+M−w is a multiple of K. The multiple of K condition assures that after crossover, the length of each bit sequence is a multiple of K. This means that each bit sequence after crossover can be interpreted as a composition of the building block functions, {ƒ₁, ƒ₂, ƒ₃, . . . , ƒ_(r)}. The numbers u and w identify the crossover locations on A and B, respectively. After crossover, bit-sequence A is [a₁, a₂, a₃, . . . , a_(u), b_(w+1), b_(w+2), . . . , b_(M)], and bit-sequence B is [b₁, b₂, b₃, . . . , b_(w), a_(u+1), a_(u+2), . . . , a_(L)].

[0092] 3.) This comment explains mutation. The bit-sequence before mutation is [b₁, b₂, b₃, . . . , b_(n)]. A mutation occurs when one of the bits is randomly chosen and its value is changed. More precisely, a random number k is chosen such that 1≦k≦n. If b_(k) equals 0, then assign b_(k) the value 1. If b_(k) equals 1, then assign b_(k) the value 0.

[0093]4.) The collection {φ₁, φ₂, . . . , φ_(m)} represents the fitnesses of the templates, {T₁ ^((i,j)), T₂ ^((i,j)), . . . , T_(m) ^((i,j))}, in the current generation. The probability that template T_(a) ^((i,j)) is chosen for the next generation is $\frac{\varphi_{a}}{\sum\limits_{k = 1}^{m}\varphi_{k}}.$

[0094] 5.) p_(crossover) should usually range from 0.3 to 0.7.

[0095] 6.) p_(mutation) should usually be less than 0.1.

General Unbounded Building Block Evolution

[0096] Before we present general UBBE, some symbols are defined and some modifications of UBBE applied to template design are explained. General UBBE designs competent task elements,

_(a), to accomplish a task Γ from a collection of building blocks. Q is the number of competent elements desired.

stores the competent elements. The fitness, φ_(a), of element

_(a) is its ability to accomplish the task Γ. As before, θ is an acceptable level of competency at performing task Γ. The method of crossover is the same as described in comment 2 and shown in the diagram titled Unbounded Crossover. The only difference is that the bit-sequences encode a composition of building blocks representing a task element rather than a template.

[0097] The method of mutation is the same as described in comment 3. Furthermore, the variables p_(crossover), p_(mutation) have the same purpose. However, for some tasks Γ, the values of p_(crossover) and p_(mutation) may lie outside the ranges recommended in comments 5 and 6. The method of encoding a composition of building blocks as a bit-sequence is the same as described near the beginning of this section. The general UBBE process is presented below.

[0098] Set

equal to the empty set.

[0099] Build an initial population of task elements, A={

₁,

₂,

₃, . . . ,

_(m)}, represented as m bit-sequences.

[0100] For each element

_(a) in A, evaluate its ability to accomplish task Γ.

[0101] Store this ability as the fitness of

_(a). while(size of

<Q) { Set G equal to the empty set. while( size of G < m) { $\begin{matrix} {{{Randomly}\quad {choose}\quad {two}\quad {elements}},{_{a}\quad {and}\quad _{b}},{{from}\quad A},\quad {{where}\quad {the}\quad {probability}\quad {of}}} \\ {{choosing}\quad {an}\quad {element}\quad _{a}\quad {for}\quad {the}\quad {next}\quad {generation}\quad {equals}\quad {\frac{\varphi_{u}}{\sum\limits_{k = 1}^{m}\varphi_{k}}.}} \\ {{Randomly}\quad {choose}\quad a\quad {number}\quad r\quad {between}\quad 0\quad {and}\quad 1.} \\ {{{{If}\quad r} < p_{crossover}},{{then}\quad {crossover}\quad {elements}\quad _{a}\quad {and}\quad {_{b}.}}} \\ {{Randomly}\quad {choose}\quad a\quad {number}\quad s_{1}\quad {between}\quad 0\quad {and}\quad 1.} \\ {{{{If}\quad s_{1}} < p_{mutation}},{{then}\quad {mutate}\quad {element}\quad {_{a}.}}} \\ {{Randomly}\quad {choose}\quad a\quad {number}\quad s_{2}\quad {between}\quad 0\quad {and}\quad 1.} \\ {{{{If}\quad s_{2}} < p_{mutation}},{{then}\quad {mutate}\quad {element}\quad {_{b}.}}} \\ {{{Set}\quad G\quad {equal}\quad {to}\quad G}\bigcup{\left\{ {_{a},_{b}} \right\}.}} \end{matrix}\quad$

} If the (size of G ) > m, then set A equal to the m elements in G with the highest fitness else set A equal to G. $\begin{matrix} {{{For}\quad {each}\quad {element}\quad _{a}\quad {in}\quad A},{{evaluate}\quad {its}\quad {ability}\quad {to}\quad {accomplish}\quad {task}\quad {\Gamma.}}} \\ {{Store}\quad {this}\quad {abiltiy}\quad {as}\quad {the}\quad {fitness}\quad {of}\quad {_{a}.}} \\ {{{For}\quad {each}\quad {element}\quad _{a}\quad {in}\quad A},{{{if}\quad {its}\quad {fitness}\quad \varphi_{a}} > \theta},{{{set}\quad \quad {equal}\quad {to}\quad }\bigcup{\left\{ _{a} \right\}.}}} \\ \left( {{\bigcup\quad {{means}\quad {set}\quad {union}}},{{so}\quad _{a}\quad {is}\quad {added}\quad {to}\quad \quad {only}\quad {if}\quad {it}\quad {is}\quad {not}\quad {already}\quad {in}\quad {.}}} \right) \end{matrix}\quad$

}

[0102] If the (size of G )>m,

[0103] then set A equal to the m elements in G with the highest fitness

[0104] else set A equal to G.

[0105] For each element

_(a) in A, evaluate its ability to accomplish task Γ.

[0106] Store this ability as the fitness of

_(a).

[0107] For each element

_(a) in A, if its fitness φ_(a)>θ, set

equal to

∪{

_(a)}.

[0108] (∪ means set union, so

_(a) is added to

only if it is not already in

.) }

UBBE Versus Prior Art

[0109] A substantial improvement of UBBE over prior art is that it evolves sequences with unbounded lengths. Prior art assumes that all of the sequences in the population are the same fixed length. In the prior art, the fixed length of the sequences limits the complexity of the elements that can be constructed from evolution.

[0110] Another substantial improvement of UBBE over prior art is UBBE's sequence encoding of a composition of building blocks. The UBBE encoding also enables each building block to have a different structure from the other building blocks. The prior art does not have a method for crossover of two bit sequences with different lengths because they assume that a fixed range of locations of the sequence always encodes for the same functionality. On the other hand, UBBE's encoding at any location in the sequence can vary. For this reason, UBBE creates a more flexible, expressive encoding mechanism. With sequences having two different lengths, the prior art's method of crossover would be unable to preserve useful (high fitness) subsets of the sequence during evolution. These useful (high fitness) subsets of the sequence are often called schema in the evolution literature. Overall, the fixed location assumption by prior art creates a debilitating limitation on what prior art sequences can encode.

[0111] E. Krugfat Applied to Handwriting Recognition

[0112] One of the big problems with wireless appliances such as cell phones and Palm handhelds is that they are too small to support a keyboard. Another problem is that companies such as FedEx have important handwritten information—mailing address, tracking numbers—on forms that they need to access on the Internet. It is very expensive, error-prone and time consuming to type this information into the computer. Consequently, there is a great demand for software that can recognize a person's handwriting.

[0113] To do this, handwriting recognition software must convert a sequence or stream of handwritten shapes, symbols or characters to a sequence of numbers that the computer uses to represent these symbols or characters. In ASCII format, the number 97 represents lowercase “a”, 98 represents lowercase “b”, 99 represents lowercase “c”, and so on. There are many different types of formats for representing symbols in a computer. The methodology presented here is independent of the format.

[0114] Below is an illustration of the basic idea. After the learning, the set of points {A, B, C, D, E, F, G, H, I, J, K, L, M}

[0115] is converted to the letter ‘a’ by the the handwriting recognition software. And the sequence of points:

[0116] is mapped to the sequence of letters: <d, o, g>. The methodology works for all types of shapes, so it works for all written languages. For example, the methodology can be trained to recognize the arabic letters:

[0117] This methodology can also be trained to recognize chinese characters:

[0118] Again, the key idea is to choose the proper templates for distinguishing the different categories of shapes. The templates can be user defined. Some user defined templates are:

[0119] 1.) The shape has a loop in it.

[0120] 2.) The shape contains no loops.

[0121] 3.) The shape has a corner(s) at the bottom of the letter.

[0122] 4.) The shape has dot(s) above or below the symbol:

[0123] 5.) The shape has a segment above or below the symbol.

[0124] 6.) The shape contains two curves that intersect:

[0125] 7.) The shape has mirror symmetry.

[0126] 8.) The shape has radial symmetry.

[0127] 9.) The shape has a vertical line in it.

[0128] 10.) The shape has a horizontal line in it.

[0129] 11.) The winding number of the shape is greater than a fixed member of radians. (This template is parameterized by a real number r so it actually represents an infinite number of templates. For example, ‘◯’ has a winding number>(2π31 ε) where ε is very small. ‘e’ has a winding number of about 2π.

[0130] 12.) The instantaneous absolute value of the winding number of the shape is greater than a fixed value.

[0131] 13.) The user must lift the pen off the paper or writing tablet to create this shape.

[0132] 14.) Foliation and intersection points.

[0133] In addition to humanly understandable templates, here are mathematical templates that are not describable in a natural language such as English. For example, the template,

[0134] distinguishes my handwritten lowercase ‘a’ from lowercase ‘b’. This template was designed by UBBE, using simple binary mathematical functions as the building blocks.

[0135] Now the handwriting recognition example is illustrated showing one trial in the recognition phase, using humanly understandable templates. The category space C={a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z}. To illustrate this example, choose the handwritten letter l to recognize:

[0136] The program initializes S=C.

[0137] STEP I.) The program randomly chooses a template. Suppose template 1. was chosen. Since the handwritten letter has no loops the following categories are removed from S: ‘a’, ‘b’, ‘d’, ‘e’, ‘g’, ‘o’, ‘p’, ‘q’. At this point, S={c, f, h, i, j, k, l, m, n, r, t, u, v, w, x, y, z}.

[0138] STEP II.) Choose a random template. Suppose template 7 was chosen. Since the handwritten letter has mirror symmetry, the following categories are removed from S: ‘c’, ‘f’, ‘h’, ‘j’, ‘k’, ‘m’, ‘n’, ‘r’, ‘s’, ‘u’, ‘y’, ‘z’. At this point, S={i, l, t, v, w, x}.

[0139] STEP III.) Choose a random template. Suppose template 6 was chosen. Since the handwritten letter does not contain two curves that intersect, the following categories are removed: ‘t’, ‘x’. At this point, S={i, l, v, w}.

[0140] STEP IV.) Choose a random template. Suppose template 9 was chosen. Since the handwritten letter has a vertical line segment, the following categories are removed: ‘w’, ‘v’. At this point, S={i, l}.

[0141] STEP V.) Choose a random template. Suppose template 4 was chosen. Since the handwritten letter has no dots above it, the category ‘i’ is removed. At this point, S={l}. Consequently, increment the category score for category ‘l’ by one. This completes the description of one trial of the recognition phase.

[0142] Additional trials are executed similarly to what was just descibed. Keep in mind that since the order of the templates is chosen randomly, in a subsequent trial, the program may choose template 12 first, and then template 5, and so on.

[0143] The handwriting recognition templates presented here are a subset of a more general collection of templates, called shape recognition templates. Shape recognition templates are comprised of templates that ascertain the geometry of a part of an object. This geometry could be in two dimensions, three dimensions or higher dimensions. Shape recognition templates are comprised of templates built for the following applications, vision recognition, speech recognition, image recognition, molecular recognition, and gene expression patterns. For example, face recognition, fingerprint recognition, and iris recognition are types of image recognition. The recognition of a part on an automated assembly line by computer software is a type of vision recognition. Molecular recognition involves the recognition of molecule based on its elements.

[0144] F. Krugfat Applied to Information Retrieval

[0145] The United States patent office may want to organize their online documents based on the subject matter. This could be a monumental task without using software. A patent examiner first designates what categories he/she wants to use for classification. For example, some of the categories in a library could be “biotech”, “electronic commerce”, “manufacturing”, “bicycles”, “transporation”, “automobiles”, “airplanes”, “motorcycles”, “finance”, “bonds”, “stocks”, “real estate”, “sports”, “baseball”, “software”, “Linux”, “bridges” and so on. (Notice that double quotes are used to surround a sequence of words representing a category.) Then the user provides examples of each particular category. For example, a sports article about the “Mets beat the Astros” is in the category “sports” and “baseball”. The documents that the software is trained on are the learning examples.

[0146] Before some extremely effective templates are described, some vocabulary is carefully defined. In what follows, ‘concept’ is used with a precise meaning illustrated by some examples. ‘Concept’ does not have the same meaning as ‘word’: ‘red’ and ‘rioja’ are different words, but represent the same concept when referring to color. ‘Ice’ and ‘solid water’ are two distinct ways to represent the same concept. Single quotes are used to surround a sequence of words representing a concept.

[0147] Based on software testing, the following templates enable the recognition phase to predict the category (subject matter) of a new—up to this point unread—document with greater than 87% accuracy, when trained on less than 100 documents per category. And these templates enable the recognition phase to predict the category of a new—up to this point unread document with greater than 93% accuracy, when trained on less than 1000 documents per category.

[0148] 1.) At least one of the following concepts occurs in the document.

[0149] 2.) All of the following concepts occur in the document.

[0150] 3.) All of the following concepts occur in the same sentence of the document.

[0151] 4.) All of the following concepts occur in this order in the document.

[0152] 5.) All of the following concepts occur in the same sentence in this order.

[0153] 6.) None of the following concepts occur in the document.

[0154] 7.) At least one of the following concepts do not occur in the document.

[0155] 8.) All of the following concepts do not occur in the same sentence of the document.

[0156] 9.) All of the following concepts do not occur in this order in the document.

[0157] 10.) All of the following concepts do not occur in the same sentence in this ORDER.

[0158] 11.) All of the following concepts occur in the same <DOER, ACTION> phrase in this document.

[0159] 12.) All of the following concepts occur in the same <DOER, ACTION, OBJECT> phrase in this document.

[0160] Comment 1:

[0161] There are an infinite number of possibilities for a <DOER, ACTION> phrase. However, this method is best explained by listing a number of examples.

[0162] Illustrative examples of <DOER, ACTION> phrases:

[0163] 1.) Kathy talks too much. DOER: ‘Kathy’. ACTION: ‘talks’.

[0164] 2.) The dog barks all night. DOER: ‘dog’. ACTION: ‘barks’.

[0165] 3.) Mary worries about her children. DOER: ‘Mary’. ACTION: ‘worries’.

[0166] 4.) The U.S. patent office wants to organize their online documents based on the subject matter. DOER: ‘U.S. patent office’. ACTION: ‘wants to organize’.

[0167] 5.) The red corvette stopped running. DOER: ‘red corvette’. ACTION: ‘stopped running’.

[0168] 6.) The dinosaurs became extinct long ago. DOER: ‘dinosaurs’. ACTION: ‘became extinct’.

[0169] 7.) The bond market will close in an hour. DOER: ‘bond market’. ACTION: ‘will close’.

[0170] 8.) My stock purchase will settle in three days. DOER: ‘stock purchase’. ACTION: ‘will settle’.

[0171] 9.) The operating system boots up. DOER: ‘operating system’. ACTION: ‘boots up’.

[0172] 10.) The option expired. DOER: ‘option’. ACTION: ‘expired’.

[0173] 11.) The glass shattered. DOER: ‘glass’. ACTION: ‘shattered’.

[0174] Comment 2:

[0175] Likewise, there are an infinite number of possibilities for a <DOER, ACTION, OBJECT> phrase. This method is also best explained by listing a number of examples.

[0176] Illustrative examples of <DOER, ACTION, OBJECT> phrases:

[0177] 1.) The gamma ray split the atom. DOER: ‘gamma ray’. ACTION: ‘split’. OBJECT: ‘atom’

[0178] 2.) The elephant ate salty peanuts. DOER: ‘elephant’. ACTION: ‘ate’. OBJECT: ‘salty peanuts’.

[0179] 3.) Mary loves Bob. DOER: ‘Mary’. ACTION: ‘loves’. OBJECT: ‘Bob’.

[0180] 4.) The corporation sold the Empire State Building. DOER: ‘corporation’. ACTION: ‘sold’. OBJECT: ‘Empire State Building’.

[0181] 5.) Harry trades bonds for a living. DOER: ‘Harry’. ACTION: ‘trades’. OBJECT: ‘bonds’.

[0182] 6.) Professor Rebholz knows Shakespeare well. DOER: ‘Professor Rebholz’. ACTION: ‘knows’. OBJECT: ‘Shakespeare’.

[0183] 7.) The pope prays to God for peace in the Middle East. DOER: ‘pope’. ACTION: ‘prays’. OBJECT ‘peace in the Middle East’.

[0184] 8.) The ship sailed to Hawaii. DOER: ‘ship’. ACTION: ‘sailed’. OBJECT: ‘Hawaii’.

[0185] 9.) The asteroid crashed into the Pacific ocean. DOER: ‘asteroid’. ACTION: ‘crashed’. OBJECT: ‘Pacific ocean’.

[0186] 10.) Father Ferapoint was silent. DOER: ‘Father Ferapoint’. ACTION: ‘was’. OBJECT: ‘silent’.

[0187] 11. Do you think that all the combined wisdom of the earth could think up anything faintly resembling in force and depth those three questions that were actually presented to you then by the powerful and intelligent spirit in the wilderness? DOER: ‘combined wisdom of the earth’. ACTION: ‘could think up’. OBJECT: ‘anything faintly resembling in force and depth those three questions that were actually presented to you then by the powerful and intelligent spirit in the wilderness’.

[0188] 12.) The miracle lay precisely in the appearance of those three questions. DOER: ‘miracle’. ACTION: ‘lay precisely’. OBJECT: ‘the appearance of those three questions’.

[0189] 13.) Abandon your gods. DOER: <Person referred to in the context of this sentence>. ACTION: ‘abandon’. OBJECT: ‘your gods’.

[0190] 14.) Come here. DOER: <Person referred to in the context of this sentence>. ACTION: ‘come’. OBJECT: <Location referred to by the word “here” in this context>.

[0191] Comment 3:

[0192] There are many additional templates that can be defined and used. One can define templates that are Boolean combinations of the templates listed here.

[0193] Template 2 instantiated with the concepts “homer” and “run” is useful for distinguishing documents lying in the “baseball” category from documents lying in the “dog” category. Template 3 instantiated with the concepts “bark” and “growl” is useful to distinguish a document lying in the category “dog” from a document lying in the category “cat”.

[0194] Using the learning examples, and many other templates similar to those mentioned above and genetically evolved templates, the learning phase builds the prototype functions T_(k)(c) as already discussed in the Learning section.

[0195] Note that there are an infinite number of templates so it is not possible to list all of them here. This includes templates used for foreign languages.

[0196] G. Krugfat Applied to Gene Expression

[0197] At this stage in the genomics revolution, scientists are still attempting to figure out which genes perform what particular functions. For example, if scientists can figure out that a mutation in gene 19, or gene 53, or gene 120 makes it more likely for a person to get lung cancer, then this knowledge greatly enables medical researchers and doctors working to prevent lung cancer. Consequently, the ability to classify groups of genes into functional—what the gene does—categories is extremely important.

[0198] The important idea here is that if a group of genes all have a similar expression pattern, then it is extremely likely that this group is working together to perform some important function for the body:

[0199] 1.) The development of a new antibody to destroy a dangerous virus, a bacteria or cancer cells.

[0200] 2.) The breakdown of toxic poisons into harmless compounds.

[0201] 3.) The conversion of sugar to energy.

[0202] 4.) The creation of new membrane proteins at a neural synapse enabling a new memory to be stored.

[0203] The four functions just mentioned are just a few of the many functions that genes code for. The goal is to classify groups of genes into the same functional category based on criteria defined by a person or software. In this example, the criterion is the gene's expression pattern. In the diagram titled Gene Expression, each square represents a different gene. In a single square, the shape that you see is a gene expression pattern: for example, the horizontal axis represents the time and the vertical axis represents the amount of that gene's expression at a certain time. As you can see, some expression patterns have similar shapes. For clarity, refer to squares in the diagram as follows: the upper left square is gene (1, 1), and the first number is the row number and the second number is the column number. Then gene (10, 1) and gene (10, 2) are similar because their expression patterns are both horizontal line segments, so these two genes are in the same category. Similarly, gene (4, 2) and gene (5, 3) are in the same category because their expression patterns each have two mountain tops with the same height.

[0204] Just as handwritten letters are categorized based on their shapes, genes are categorized based on their gene expression patterns. Below is a list of some, but not all, of the templates that can be constructed to categorize gene expression.

[0205] 1.) The slope of any tangent line to the expression graph is greater than zero. Travelling from left to right, the graph is uphill. Examples:

[0206] 2.) The slope of any tangent line to the expression graph is less than zero. Travelling from left to right, the graph is downhill. Examples:

[0207] 3.) The expression graph is concave up. Examples:

[0208] 4.) The expression graph is concave down. Examples:

[0209] 5.) The expression graph has n local maxima, where n can be 1, 2, 3, 4, . . . The expression graph has 2 mountain tops. Examples:

[0210] 6.) The expression graph has n local minima, where n can be 1, 2, 3, 4, . . . The expression graph has 2 valley bottoms. Examples:

[0211] 7.) In the expression graph, the first mountaintop is lower than the second mountaintop. Examples:

[0212] 8.) In the expression graph, the first mountaintop is higher than the second mountaintop. Examples:

[0213] 9.) In the expression graph, the first valley is lower than the second valley. Examples:

[0214] 10.) It the expression graph, the first valley is higher than the second valley. Examples:

[0215] H. Building Analogies with Adaptable Templates

[0216] In addition to the notion of templates, there is a notion of a template map: a template map can be a relation on a set of all templates in a template space, or the analogous notion to set theory in mathematical category theory—a collection of morphisms. This is useful because it enables KRUGFAT, to create representations of analogies, and equivalence classes that allow for fuzzy pattern recognition, classification, and the linking of knowledge across very different domains.

[0217] A template map takes a template as its function argument and returns a template as its image. In other words, the domain and range of a template map are a space of templates. (One implementation is shown in the JAVA source code.) For templates that are represented as a finite sequence of variables ν₁, ν₂, ν₃, . . . , ν_(n), some of the more important template maps are the mirror map, the projection map, the shift map, and the composition map.

[0218] The mirror map is mirror(x)=−x if the template x is an element of a vector space. If not, then mirror(ν₁, ν₂, ν₃)=(ν₃, ν₂, ν₁) In the more general case, mirror(ν₁, ν₂, ν₃, . . . , ν_(n))=(ν_(n), . . . , ν₃, ν₂, ν₁).

[0219] The projection maps project a number of template variables to a lower dimension. For example, proj_((1,3))(ν₁, ν₂, ν₃)=(ν₁, ν₃). And proj_((1,3,4))(ν₁, ν₂, ν₃, ν₄)=(ν₁, ν₃, ν₄). Obviously, there are an infinite number of distinct projection maps.

[0220] The shift map takes a template and shifts the variables by 1 position. For example, if the template is (ν₁, ν₂, ν₃, ν₄), then shift(ν₁, ν₂, ν₃, ₄)=(ν₄, ν₁, ν₂, ν₃).

[0221] The composition map is a template map which is created with two arguments that are template maps. It creates a new template map by taking the function composition of these two template maps.

[0222] When there is more structure to the templates, the template maps take on a different form. For example, the variables in the template could have a two dimensional topology or an n-dimensional topology. Also, the template could even have a tree topology:

[0223] Bibiliography

[0224] [BLEDSOE] Bledsoe, W. W. (1961) The use of biological concepts in the analytical study of systems. ORSA-TIMS National Meeting, San Francisco, Calif.

[0225] [BOX] Box, G. E. P. (1957) Evolutionary operation: A method for increasing industrial production. Journal of the Royal Statistical Society, C, 6(2), 81-101.

[0226] [BREMERMANN] Bremermann, R. J. (1962) Optimization through evolution and recombination. Self-organizing systems. pp. 93-106. Washington, D.C., Spartan Books.

[0227] [CHINESE CHARACTERS] http://www.geocities.com/hao510/charfreq)

[0228] [DEEP BLUE] Feng-hsiung Hsu, Thomas Anantharaman, Murray Campbell, and Andreas Nowatzyk. (1990). A Grandmaster Chess Machine. Scientific American, October edition.

[0229] [FEYNMAN] Feynman, Richard. ‘Surely, You're joking, Mr. Feynman!’: Adventures of a Curious Character; W. W. Norton & Company. ISBN: 0-3933-1604-1. (In the relevant section of the book, Feynman discusses the Example of the A+ physics student from Brazil that can't apply his esoteric physics knowledge of dielectrics to a simple dielectric physics problem in the real world.)

[0230] [FISKE 1] Fiske, Michael. (1997). Non-autonomous Dynamical Systems applicable to Neural Computation. Ph.D. Thesis. Bell & Howell Company, 1997. Northwestern University, UMI Number: 9714584.

[0231] [FRIEDMAN] Friedman, G. J. (1959) Digital simulation of an evolutionary process. General Systems Yearbook, 4, 171-184.

[0232] [GIBAS, JAMBECK] Gibas, Cynthia and Jambeck, Per. (2001). Developing Bioinformatics Computer Skills. Authors: O'Reilly & Associates. ISBN 1-56592-664-1

[0233] [HALMOS] Paul R. Halmos. (1974). Naive Set Theory. Springer-Verlag ISBN 0-387-90092-6

[0234] [HERTZ, KROGH, PALMER] Hertz, John, Krogh, Anders, and Palmer, Richard (1991). Introduction to The Theory of Neural Computation. pp. 124-129. Addison-Wesley Publishing Company. ISBN 0-201-51560-1

[0235] [HOLLAND—1] Holland, J. H. (1973a). Genetic algorithms and the optimal allocation of trials. SIAM Journal of Computing, 2(2), 88-105.

[0236] [HOLLAND_(—)2] Holland, J. H. (1981) Genetic algorithms and adaptation. (Technical Report no. 34) Ann Arbor: University of Michigan. Department of Computer and Communication Sciences.

[0237] [MINSKY] Minsky, Marvin. (1990). Logical vs. Analogical or Symbolic vs. Connectionist or Neat vs. Scruffy”, in Artificial Intelligence at MIT. Expanding Frontiers, Patrick H. Winston (Ed.), Volume 1, MIT Press. Also, on the web at: http://web.media.mit.edu/minsky/papers/SymbolicVs.Connectionist.html

[0238] [RIESBECK, SCHANK] Riesbeck, Christopher and Schank, Roger. (1989). Inside Case-Based Reasoning. Lawrence Erlbaum Associates, ISBN 0-89859-767-6

[0239] [WITTGENSTEIN] Wittgenstein, Ludwig. (1953). Philosophical Investigations. 

I claim:
 1. A machine comprising: (a) a memory which stores a collection of templates, (b) a learning component which constructs said templates, whereby said machine does not get stuck in local minima, and whereby said machine enhances what any machine can learn, and whereby said machine greatly increases the speed, and whereby said machine enhances the representation of knowledge.
 2. The machine of claim 1 wherein one or more category spaces are used.
 3. The machine of claim 1 wherein one or more possibility spaces are used.
 4. The machine of claim 1 wherein said templates are user-created.
 5. The machine of claim 1 wherein evolution is used.
 6. The machine of claim 1 wherein template maps are used.
 7. The machine of claim 1 wherein matching functions are used.
 8. The machine of claim 1 wherein template value functions are used.
 9. The machine of claim 1 wherein prototype functions are used.
 10. The machine of claim 1 wherein templates are removed from the template set.
 11. The machine of claim 1 wherein shape recognition templates are used.
 12. The machine of claim 1 wherein information retrieval templates are used.
 13. The machine of claim 1 wherein bioinformatics templates are used.
 14. A machine comprising: (a) a memory which stores a collection of templates, (b) a recognition component which utilizes said templates, whereby said machine greatly increases the speed, and whereby said machine greatly increases the accuracy, and whereby said machine enhances the patterns, information and/or knowledge that any machine can retrieve, categorize, classify and/or recognize.
 15. The machine in claim 14 wherein templates are chosen randomly.
 16. The machine in claim 15 wherein a non-uniform probability distribution is used.
 17. The machine in claim 14 wherein matching functions are used.
 18. The machine in claim 14 wherein categories are removed during execution of said recognition component.
 19. The machine in claim 14 wherein an example is in zero or more categories.
 20. The machine in claim 14 wherein templates are user-created.
 21. The machine in claim 14 wherein templates were constructed from evolution.
 22. The machine of claim 14 wherein shape recognition templates are used.
 23. The machine of claim 14 wherein information retrieval templates are used.
 24. The machine of claim 14 wherein bioinformatics templates are used.
 25. A machine comprising: (a) evolution which builds competent elements from building blocks, (b) a memory which stores said elements, whereby said machine enhances the competency of said elements constructed, and whereby said machine greatly increases the speed at which said elements are constructed.
 26. The machine in claim 25 wherein unbounded sequences are used.
 27. The machine in claim 25 wherein sequences with different lengths are used.
 28. The machine in claim 27 wherein sequence encoding at a location is variable.
 29. The machine in claim 25 wherein said building blocks are functions.
 30. The machine in claim 25 wherein said elements are selected from the group consisting of templates and components of templates.
 31. The machine in claim 30 wherein the fitness of said elements depends on their ability to distinguish examples.
 32. The machine in claim 25 wherein sequences encode a composition of building blocks.
 33. The machine in claim 25 wherein the crossover locations are different.
 34. The machine in claim 25 wherein the fitness of an element depends on its computational time.
 35. The machine in claim 25 wherein the fitness of an element depends on its memory usage.
 36. The machine in claim 25 wherein the fitness of an element depends on its competence.
 37. A method of building a representation of patterns and/or information and/or knowledge, comprising: (a) using a memory which stores a collection of templates, (b) executing a learning phase which constructs said templates, whereby said method does not get stuck in local minima, and whereby said method enhances what any method can learn, and whereby said method greatly increases the speed, and whereby said method enhances what can be represented.
 38. The method of claim 37 wherein one or more category spaces are used.
 39. The method of claim 37 wherein one or more possibility spaces are used.
 40. The method of claim 37 wherein said templates are user-created.
 41. The method of claim 37 wherein evolution is used.
 42. The method of claim 37 wherein template maps are used.
 43. The method of claim 37 wherein matching functions are used.
 44. The method of claim 37 wherein template value functions are used.
 45. The method of claim 37 wherein prototype functions are used.
 46. The method of claim 37 wherein templates are removed from the template set.
 47. The method of claim 37 wherein shape recognition templates are used.
 48. The method of claim 37 wherein information retrieval templates are used.
 49. The method of claim 37 wherein bioinformatics templates are used.
 50. A method comprising: (a) using a memory which stores a collection of templates, (b) executing a recognition phase which utilizes said templates, whereby said templates greatly increase the speed, and whereby said templates greatly increase the accuracy, and whereby said templates enhance the patterns, information and/or knowledge that any method can retrieve, categorize, classify and/or recognize.
 51. The method in claim 50 wherein templates are chosen randomly.
 52. The method in claim 51 wherein a non-uniform probability distribution is used.
 53. The method in claim 50 wherein matching functions are used.
 54. The method in claim 50 wherein categories are removed during execution of said recognition component.
 55. The method in claim 50 wherein an example is in zero or more categories.
 56. The method in claim 50 wherein user-created templates are used.
 57. The method in claim 50 wherein templates were constructed from evolution.
 58. The method of claim 50 wherein shape recognition templates are used.
 59. The method of claim 50 wherein information retrieval templates are used.
 60. The method of claim 50 wherein bioinformatics templates are used.
 61. A means for information retrieval comprising: (a) a memory which stores a collection of templates, (b) a retrieval phase which retrieves information using said templates.
 62. The means in 61 wherein one or more said templates use a <DOER, ACTION> phrase.
 63. The means in 61 wherein one or more said templates use a <DOER, ACTION, OBJECT> phrase.
 64. The means in 61 wherein one or more said templates are concept templates.
 65. The means in 64 wherein said concept templates are selected from the group consisting of: at least one of the following concepts occur; all of the following concepts occur; all of the following concepts occur in the same sentence; all of the following concepts occur in this order; all of the following concepts occur in the same sentence in this order; none of the following concepts occur; at least one of the following concepts do not occur; all of the following concepts do not occur in the same sentence; all of the following concepts do not occur in this order; all of the following concepts do not occur in the same sentence in this order; all of the following concepts occur in the same <DOER, ACTION> phrase; all of the following concepts occur in the same <DOER, ACTION, OBJECT> phrase. 